home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / nihcl-30.lha / nihcl-3.0 / lib / Template_c < prev    next >
Text File  |  1990-05-19  |  7KB  |  252 lines
  1. /* Template.c  -- example implementation of an NIH Library class
  2.  
  3.     THIS SOFTWARE FITS THE DESCRIPTION IN THE U.S. COPYRIGHT ACT OF A
  4.     "UNITED STATES GOVERNMENT WORK".  IT WAS WRITTEN AS A PART OF THE
  5.     AUTHOR'S OFFICIAL DUTIES AS A GOVERNMENT EMPLOYEE.  THIS MEANS IT
  6.     CANNOT BE COPYRIGHTED.  THIS SOFTWARE IS FREELY AVAILABLE TO THE
  7.     PUBLIC FOR USE WITHOUT A COPYRIGHT NOTICE, AND THERE ARE NO
  8.     RESTRICTIONS ON ITS USE, NOW OR SUBSEQUENTLY.
  9.  
  10. Author:
  11.     K. E. Gorlen
  12.     Bg. 12A, Rm. 2033
  13.     Computer Systems Laboratory
  14.     Division of Computer Research and Technology
  15.     National Institutes of Health
  16.     Bethesda, Maryland 20892
  17.     Phone: (301) 496-1111
  18.     uucp: uunet!nih-csl!kgorlen
  19.     Internet: kgorlen@alw.nih.gov
  20.     February, 1987
  21.  
  22. Function:
  23.     
  24. Modification History:
  25.  
  26. $Log:    Template_c,v $
  27. # Revision 3.0  90/05/20  00:21:40  kgorlen
  28. # Release for 1st edition.
  29. # 
  30. */
  31.  
  32. #include "THIS_CLASS.h"
  33. #include "nihclIO.h"
  34. // #include .h files for other classes used
  35.  
  36. #define    THIS    THIS_CLASS
  37. // Define BASE only for classes with one base class
  38. #define    BASE    BASE_CLASS
  39. // Define list of addresses of descriptors of all base classes:
  40. #define    BASE_CLASSES BASE::desc()
  41. // Define list of addresses of descriptors of all member classes:
  42. #define    MEMBER_CLASSES
  43. // Define list of addresses of descriptors of all virtual base
  44. // classes:
  45. #define VIRTUAL_BASE_CLASSES
  46.  
  47. DEFINE_CLASS(THIS_CLASS,1,"$Header: /afs/alw.nih.gov/unix/sun4_40c/usr/local/src/nihcl-3.0/share/lib/RCS/Template_c,v 3.0 90/05/20 00:21:40 kgorlen Rel $",NULL,NULL);
  48. // For abstract classes:
  49. //DEFINE_ABSTRACT_CLASS(THIS_CLASS,1,"$Header: /afs/alw.nih.gov/unix/sun4_40c/usr/local/src/nihcl-3.0/share/lib/RCS/Template_c,v 3.0 90/05/20 00:21:40 kgorlen Rel $",NULL,NULL);
  50. // For non-abstract classes with multiple base classes:
  51. //DEFINE_CLASS_MI(THIS_CLASS,1,"$Header: /afs/alw.nih.gov/unix/sun4_40c/usr/local/src/nihcl-3.0/share/lib/RCS/Template_c,v 3.0 90/05/20 00:21:40 kgorlen Rel $",NULL,NULL);
  52. // For abstract classes with multiple base classes:
  53. //DEFINE_ABSTRACT_CLASS_MI(THIS_CLASS,1,"$Header: /afs/alw.nih.gov/unix/sun4_40c/usr/local/src/nihcl-3.0/share/lib/RCS/Template_c,v 3.0 90/05/20 00:21:40 kgorlen Rel $",NULL,NULL);
  54.  
  55. extern const int // error codes
  56.  
  57. /* _castdown() for classes with multiple base classes:
  58.  
  59. void* THIS_CLASS::_castdown(const Class& target) const
  60. // (Probably a good candidate for memoization.)
  61. {
  62.     if (&target == desc()) return (void*)this;
  63.     void* p = BASE1::_castdown(target);
  64.     void* q = p;
  65.     if (p = BASE2::_castdown(target)) ambigCheck(p,q,target);
  66. // ...
  67.     if (p = BASEn::_castdown(target)) ambigCheck(p,q,target);
  68.     return q;
  69. }
  70.  
  71. */
  72.  
  73. bool THIS_CLASS::operator==(const THIS_CLASS& a) const
  74. // Test two instances of THIS_CLASS for equality
  75. {
  76. }
  77.  
  78. const Class* THIS_CLASS::species() const
  79. // Return a pointer to the descriptor of the species of this class
  80. {
  81.     return &classDesc;
  82. }
  83.  
  84. bool THIS_CLASS::isEqual(const Object& p) const
  85. // Test two objects for equality
  86. {
  87.     return p.isSpecies(classDesc) && *this==castdown(p);
  88. }
  89.  
  90. unsigned THIS_CLASS::hash() const
  91. // If two objects are equal (i.e., isEqual) they must have
  92. // the same hash
  93. {
  94. }
  95.  
  96. int THIS_CLASS::compare(const Object& p) const
  97. // Compare two objects.  If *this > p return >0,
  98. // *this == p return 0, and if *this < p return <0.
  99. {
  100.     assertArgSpecies(p,classDesc,"compare");
  101. }
  102.  
  103. void THIS_CLASS::deepenShallowCopy()
  104. // Called by deepCopy() to convert a shallow copy to a deep copy.
  105. // deepCopy() makes the shallow copy by calling the copy
  106. // constructor.
  107. {
  108. /*
  109. Deepen base classes in order specified in class declaration.
  110.  
  111. Deepen virtual base classes (VBase):
  112.     VBase::deepenVBase();        // do not do this for class Object
  113.  
  114. Deepen non-virtual base classes (BASE):
  115.     BASE::deepenShallowCopy();    // do not do this for class Object
  116.  
  117. Nothing need be done for member variables that are fundamental
  118. types.  Copy a member variable o that is an NIHCL object:
  119.     o.deepenShallowCopy();
  120.  
  121. Copy a member variable p that is a pointer to an NIHCL object of
  122. class CLASS:
  123.     p = (CLASS*)p->deepCopy();
  124. */
  125. }
  126.  
  127. void THIS_CLASS::printOn(ostream& strm) const
  128. // Print this object on an ostream
  129. {
  130. }
  131.  
  132. // Object I/O
  133.  
  134. /*
  135. Member class instances are constructed in the order they are
  136. declared in the class declaration, regardless of the order they
  137. appear in the constructor initialization list, so they must be
  138. stored in this order.  Note that member class instances are
  139. constructed before body of constructor is executed.
  140. */
  141.  
  142. // Construct an object from OIOin "strm".
  143. THIS_CLASS::THIS_CLASS(OIOin& strm)
  144. :
  145. #ifdef MI
  146.     Object(strm),
  147. #endif
  148. /*
  149. Call readFrom() constructors of all ancestor virtual base classes:
  150.     VBase(strm),
  151. */
  152.     BASE(strm)
  153. /*
  154. Read a member variable o that is an instance of an NIHCL class:
  155.     o(strm)
  156. {
  157. Read a member variable f that is a fundamental type using ">>":
  158.     strm >> f;
  159.  
  160. Read a member variable p that is a pointer to an instance of
  161. the NIHCL class CLASS:
  162.     p = CLASS::readFrom(strm);
  163.  
  164. Read member variables in the same order that they are stored.
  165. */
  166. }
  167.  
  168. void THIS_CLASS::storer(OIOout& strm) const
  169. // Store the member variables of this object on OIOout "strm".
  170. {
  171. /*
  172. Store virtual base classes (VBase) in inheritance DAG order:
  173.     VBase::storeVBaseOn(strm);
  174.  
  175. Store non-virtual base classes in order specified in class
  176. declaration:
  177.     BASE::storer(strm);
  178.  
  179. Store a member variable f that is a fundamental type using "<<":
  180.     strm << f;
  181.  
  182. Store a member variable o that is an instance of the NIHCL class
  183. CLASS:
  184.     o.storeMemberOn(strm);
  185.  
  186. Store a member variable p that is a pointer to an instance of an
  187. NIHCL class:
  188.     p->storeOn(strm);
  189.  
  190. Store member variables in the same order that they are read.
  191. */
  192. }
  193.  
  194. // Construct an object from file descriptor "fd".
  195. THIS_CLASS::THIS_CLASS(OIOifd& fd)
  196. :
  197. #ifdef MI
  198.     Object(fd),
  199. #endif
  200. /*
  201. Call readFrom() constructors of all ancestor virtual base classes:
  202.     VBase(fd),
  203. */
  204.     BASE(fd)
  205. /*
  206. Read a member variable o that is an instance of an NIHCL class:
  207.     o(fd)
  208. {
  209. Read a member variable f that is a fundamental type:
  210.     fd >> f;
  211.  
  212. Read a member variable a that is a pointer to an array of length l:
  213.     fd.get(a,l);
  214.  
  215. Read a member variable p that is a pointer to an instance of the
  216. NIHCL class CLASS:
  217.     p = CLASS::readFrom(fd);
  218.  
  219. Read member variables in the same order that they are stored.
  220. */
  221. }
  222.  
  223. void THIS_CLASS::storer(OIOofd& fd) const
  224. // Store an object on file descriptor "fd".
  225. {
  226. /*
  227. Store virtual base classes (VBase) in inheritance DAG order:
  228.     VBase::storeVBaseOn(fd);
  229.  
  230. Store non-virtual base classes in order specified in class
  231. declaration:
  232.     BASE::storer(fd);
  233.  
  234. Store a member variable f that is a fundamental type:
  235.     fd << f;
  236.  
  237. Store a member variable a that is a pointer to an array
  238. of length l:
  239.     fd.put(a,l);
  240.  
  241. Store a member variable o that is an instance of the NIHCL class
  242. CLASS:
  243.     o.storeMemberOn(fd);
  244.  
  245. Store a member variable p that is a pointer to an instance of an
  246. NIHCL class:
  247.     p->storeOn(fd);
  248.  
  249. Store member variables in the same order that they are read.
  250. */
  251. }
  252.